package Sync.Tool;

import java.io.File;
import java.util.ArrayList;
import java.util.List;

public class CreatFiles {

    /**
     * 处理PC端和手机端文件夹同步的方法
     * 1. 找出PC端独有文件夹并返回
     * 2. 为手机端独有文件夹在PC端创建实际文件夹
     *
     * @param pcDirs PC端文件夹相对路径列表
     * @param phoneDirs 手机端文件夹相对路径列表
     * @param pcAbsolutePath PC端绝对路径
     * @return PC端独有文件夹列表（已转换路径分隔符）
     */
    public static List<String> processFolderSync(List<String> pcDirs, List<String> phoneDirs,File pcAbsolutePath) {
        // 找出PC端独有文件夹（在PC端但不在手机端）
        List<String> pcOnlyDirs = new ArrayList<>();
        for (String pcDir : pcDirs) {
            if (!phoneDirs.contains(pcDir)) {
                pcOnlyDirs.add(pcDir);
            }
        }

        // 找出手机端独有文件夹（在手机端但不在PC端）
        List<String> phoneOnlyDirs = new ArrayList<>();
        for (String phoneDir : phoneDirs) {
            if (!pcDirs.contains(phoneDir)) {
                phoneOnlyDirs.add(phoneDir);
            }
        }

        // 为手机端独有文件夹在PC端创建实际文件夹
        for (String relativePath : phoneOnlyDirs) {
            CreatFiles.createSubFolders(pcAbsolutePath, relativePath);
        }

        // 转换PC端独有文件夹的路径分隔符并返回
        return CreatFiles.convertPathSeparators(pcOnlyDirs);
    }

    /**
     * 获取目录下所有子文件夹的相对路径
     *
     * @param dir 目录文件
     * @return 所有子文件夹的相对路径列表
     */
    public static List<String> getAllSubdirectoriesRelativePaths(File dir) {
        List<String> relativePaths = new ArrayList<>();
        getAllSubdirectoriesRelativePathsRecursive(dir, relativePaths, "");
        return relativePaths;
    }

    /**
     * 递归获取所有子目录的相对路径
     *
     * @param currentDir 当前目录
     * @param relativePaths 相对路径列表
     * @param currentRelativePath 当前相对路径
     */
    public static void getAllSubdirectoriesRelativePathsRecursive(File currentDir,
                                                                  List<String> relativePaths, String currentRelativePath) {
        // 获取当前目录下的所有文件和文件夹
        File[] files = currentDir.listFiles();
        if (files == null) {
            return;
        }

        for (File file : files) {
            if (file.isDirectory()) {
                // 构建相对于根目录的路径
                String relativePath;
                if (currentRelativePath.isEmpty()) {
                    relativePath = file.getName();
                } else {
                    relativePath = currentRelativePath + "\\" + file.getName();
                }

                // 添加到结果列表
                relativePaths.add(relativePath);

                // 递归处理子目录
                getAllSubdirectoriesRelativePathsRecursive(file, relativePaths, relativePath);
            }
        }
    }

        /**
         * 将Windows路径分隔符（反斜杠）转换为Unix路径分隔符（正斜杠）
         *
         * @param paths 包含Windows风格路径的字符串列表
         * @return 转换为Unix风格路径的字符串列表
         */
        public static List<String> convertPathSeparators(List<String> paths) {
            List<String> convertedPaths = new ArrayList<>();

            for (String path : paths) {
                // 将反斜杠替换为正斜杠
                String convertedPath = path.replace("\\", "/");
                convertedPaths.add(convertedPath);
            }

            return convertedPaths;
        }


    /**
     * 创建多级子文件夹的静态方法
     *
     * @param rootDir 根目录（File对象）
     * @param relativePath 相对路径（父文件夹/子文件夹）
     */
    public static void createSubFolders(File rootDir, String relativePath) {
        // 使用根目录和相对路径创建File对象
        File folder = new File(rootDir, relativePath);

        // 判断子文件夹是否存在
        if (!folder.exists()) {
            // 创建多级子文件夹
            folder.mkdirs();
        }
    }
    /**
     * 检查目录下是否存在名为"编辑时间较旧的文件保存"的子文件夹，如果不存在则创建该文件夹
     * @param dir 目录文件
     * @return 子文件夹File对象
     */
    public static File createOldFilesDirectory(File dir) {
        if (dir == null || !dir.exists() || !dir.isDirectory()) {
            return null;
        }

        File oldFilesDir = new File(dir, "编辑时间较旧的文件保存");
        if (!oldFilesDir.exists()) {
            oldFilesDir.mkdirs();
        }

        return oldFilesDir;
    }

}
